/**
 * 
 * @author ARCHADE
 * @version 1.0
 *

//Attention, fichier non utilisé

import java.util.*; // necessaire pour les ArrayList et autres ...
public class TabDynamique
{
  // le stockage des elements se font dans data
  // La capacit� est la longueur du tableau
  private int[] data; // j'ai prit int au hasard pour des eventuels test
   
  // le nombre d'element (taille logique).
  // Doit etre plus petite que la capacit�
  private int size;
   
  // Construit un tableau dynamique Vide [size=0]
  public TabDynamique()
  {
    data = new int[20]; // mauvais choix de vouloir l'initialiser a 20, on peut cependant l'initialser avec une variable :p[voir le deuxieme constructeur]
    size = 0;
  }
   
  // Construit un tableau Dynamique vide o� l'on specifie la capacit� nous meme
  public TabDynamique(int capacity)
  {
    if (capacity < 20)
    capacity = 20; // force a avoir une taille assez large, 20 dans mon exemple
    data = new int[capacity];
    size = 0;
  }
   
  // Augmentation de la capacit�, si n�cessaire, afin de s'assurer que 
  // Il peut contenir au moins le nombre d'�l�ments 
  // Sp�cifi� par l'argument de capacit� minimale.
  public void ensureCapacity(int minCapacity)
  {
    int oldCapacity = data.length;
    if (minCapacity > oldCapacity)
    {
      int newCapacity = (oldCapacity * 2);
      if (newCapacity < minCapacity)
        newCapacity = minCapacity;
      data = Arrays.copyOf(data, newCapacity);
    }
  }
   
  // Return la taille logique
  public int size()
  {
    return size;
  }
   
  public boolean isEmpty()
  {
    return size == 0;
  }
   
  // verifie si l'index donn�e est dans la limite de la taille 
  private void rangeCheck(int index)
  {
    if (index >= size || index < 0)
      throw new IndexOutOfBoundsException("Index: " + 
            index + ", Size: " + size);
  }
   
  // Retourne l'element a l'index sp�cifi�
  public int get(int index)
  {
    rangeCheck(index);
    return data[index];
  }
   
  // Ajoute l'�l�ment a la fin du tableau
  public boolean add(int element)
  {
    ensureCapacity(size + 1);
    data[size++] = element;
    return true;
  }
   
  // Enleve tou les elements du tableau
  public void clear()
  {
    size = 0;
  }
   
  // Remplace l'element a l'index sp�cifi� 
  public int set(int index, int element)
  {
    rangeCheck(index);
    int oldValue = data[index];
    data[index] = element;
    return oldValue;
  }
   
  public int capacity()
  {
    return data.length;
  }
}

/**
 * test conversion Tableau en Liste 
 *  implantation des fonctions ajout, suppression etc ...
 *  autre alternative par rapport a la classe tabDynamique [les ArrayList = tableau dynamique ou presque]  
 *  autre alternative encore les Vector ( mais deconseill� ) :Vector<Integer> v=new Vector<Integer>(5,2);
 *  v.addElement(int);
 */

/**
 * creation d'une nouvelle ArrayList en sp�cifiant le type
 * peut etre <Integer> ; <String> ; <Boolean> ; voir meme une class ou un objet donn�
 */

//List l = new ArrayList();
//ArrayList<Integer> listA = new ArrayList<Integer>();
//ArrayList<String> liste = new ArrayList<String>(); 
//listA.add(1);
//listA.add(2);

// ArrayList<xClass> liste = new ArrayList<xClass>(); // creation d'une nouvelle ArrayList
// liste.add( new xClass() ); 	// Ajout en queue de liste
//liste.add(1,"grape"); // ajoute l'element � l'index numeros 1 i.e l'ajoute comme etant le second element [ArrayList s'occupe de deplacer les elements et mettre a jour la taille]
//liste.remove(0); // Supprime le premier element
//liste.remove (int i);	Retire l'objet de l'indice i et le renvoie
//liste.remove("grape"); // Supprime l'element nomm� "grape"
//liste.removeAll(Collection<?> c) [addAll aussi existe]// Removes from this list all of its elements that are contained in the specified collection
//liste.set( index , element ) // modification de l'element element a la position index
// liste.size(); 				//  Avoir la taille : 
//System.out.println(liste.get(1)); // Affiche le second element de la liste
// liste.clear();	Vide compl�tement la liste
// [boolean] liste.isEmpty();	Permet de savoir si la liste est vide
// [boolean] liste.contains (Object o);	Permet de savoir si la liste contient l'objet o
// liste.clone() //Returns a shallow copy of this ArrayList instance.
//subList(int fromIndex, int toIndex)//Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive.

/** convertir une ArrayList en Array [tableau]
 * avec la methode list.toArray 
 */
 // conversion en tableau
// <xClass> [] array = list.toArray( new <xClass>[ list.size() ] );
// on peut faire de nouveau array.length pour avoir la longueur du tableau

/** la recherche dans une ArrayList [Deux maniere]
* 1� : avec un Iterator 
* 2� : avec la boucle for
*/
// Iterator <xClass> itr = liste.iterator();
// while(itr.hasNext()) // boucle par rapport aux elements
//     System.out.println(itr.next()); // Affiche l'element o� itr pointe

// for(int i=0;i< liste.size();i++) // tourne dans la boucle jsuqu'� la taille de l'ArrayList
//     System.out.println(liste.get(i)); // Affiche la liste avec la methode get  

/** resizer (( redonner de l'espace a une ArrayList 
 * exemple : voir ci-dessous
 */

// int preserveLength = Math.min(oldSize, newSize);
//  if (preserveLength > 0)
//    System.arraycopy(array, 0,
//        newArray, 0, preserveLength);
//  return newArray;



